home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part2 / 16503 < prev    next >
Encoding:
Text File  |  1996-08-05  |  5.6 KB  |  152 lines
  1. Path: news.crd.ge.com!rebecca!rpi!not-for-mail
  2. From: rcauvin@natinst.com (Roger L. Cauvin)
  3. Newsgroups: comp.lang.c++,comp.lang.c++.moderated
  4. Subject: Comparison Operators Solution (was Re: Virtual function question)
  5. Date: 10 Apr 1996 18:28:21 -0000
  6. Organization: National Instruments
  7. Sender: cppmods@netlab.cs.rpi.edu
  8. Approved: Dietmar.Kuehl@uni-konstanz.de
  9. Message-ID: <4kguk5$5au@netlab.cs.rpi.edu>
  10. References: <4jp6e9$ou5@dub-news-svc-1.compuserve.com> <4ked7o$8g3@dub-news-svc-1.compuserve.com>
  11. NNTP-Posting-Host: netlab.cs.rpi.edu
  12. X-Original-Date: 10 Apr 1996 17:45:52 GMT
  13.  
  14. In article <4ked7o$8g3@dub-news-svc-1.compuserve.com>, RossBoylan@aol.com
  15. (Ross Boylan) wrote:
  16.  
  17. > Problem:  To define the comparison operators <, <=, >, ==, etc in
  18. > terms of one or two primitives (< and maybe ==), so that all classes
  19. > for which the comparisons make sense only require definition of the
  20. > primitives.
  21. > 
  22. > Solutions
  23. > 1) The best solution I've seen is in the Standard Template library
  24. > 
  25. > My original problem statement used member functions, but the symmetric
  26. > free-standing functions are more appropriate to the comparison
  27. > operators. 
  28. > 
  29. > 2)  The remaining solutions use member functions (Borland's library
  30. > apparently does this) and create bogus functions which take abstract
  31. > classes as arguments.  In the following, RBMagnitude::operator< is not
  32. > virtual, so subclasses do not need to override it (they ignore it
  33. > instead).
  34. > 3) Several people suggested casting down as a possibility
  35. > 
  36. > 4) My original problem defined all RBMagnitude operators as virtual.
  37. > I have some potential subclasses which redefine all the inequality
  38. > operators.  However, the gain in computing comparisons directly may be
  39. > offset by the overhead of virtual functions, and it is probably
  40. > clearner not to use virtual functions.
  41. > 
  42. > 5) Scott Meyer's new book, More Effective C++, has some material in
  43. > item 33 which may be relevant (I haven't had a chance to look at it
  44. > yet).
  45.  
  46. I consider none of the "solutions" offered above to be ideal.  A solution
  47. that I do consider to be ideal is similar to the second proposal. 
  48. Conceptually, any class of objects that allows comparison operations
  49. is-a-kind-of comparable object.  So how about a ComparableObject abstract
  50. base class?  It should actually be a class template:  a number is
  51. comparable to other numbers and to native numeric types, a string is
  52. comparable to other strings and to native C strings.  The template
  53. parameter specifies the type of the value with which a ComparableObject
  54. can be compared.  Concrete classes such as Number and String are derived
  55. from ComparableObject template class(es).
  56.  
  57. The following solution maximizes code sharing and concepual clarity, and
  58. allows overriding of all the comparison operations:
  59.  
  60. template <class ValueType>
  61. class ComparableObject
  62.   {
  63.   public:
  64.     friend bool operator==(const ComparableObject &comparableObject,
  65. ValueType value);
  66.     friend bool operator==(ValueType value, const ComparableObject
  67. &comparableObject);
  68.     friend bool operator!=(const ComparableObject &comparableObject,
  69. ValueType value);
  70.     friend bool operator!=(ValueType value, const ComparableObject
  71. &comparableObject);
  72.     friend bool operator<(const ComparableObject &comparableObject,
  73. ValueType value);
  74.     friend bool operator<(ValueType value, const ComparableObject
  75. &comparableObject);
  76.     friend bool operator<=(const ComparableObject &comparableObject,
  77. ValueType value);
  78.     friend bool operator<=(ValueType value, const ComparableObject
  79. &comparableObject);
  80.     friend bool operator>(const ComparableObject &comparableObject,
  81. ValueType value);
  82.     friend bool operator>(ValueType value, const ComparableObject
  83. &comparableObject);
  84.     friend bool operator>=(const ComparableObject &comparableObject,
  85. ValueType value);
  86.     friend bool operator>=(ValueType value, const ComparableObject
  87. &comparableObject);
  88.  
  89.   protected:
  90.     virtual bool IsEqualTo(ValueType value) = 0;
  91.     virtual bool IsNotEqualTo(ValueType value);
  92.     virtual bool IsLessThan(ValueType value) = 0;
  93.     virtual bool IsLessThanOrEqualTo(ValueType value);
  94.     virtual bool IsGreaterThan(ValueType value);
  95.     virtual bool IsGreaterThanOrEqualTo(ValueType value);
  96.  
  97.   private:
  98.   };
  99.  
  100. Comparison operators in ComparableObject are implemented as calls to
  101. protected virtual functions.  E.g.:
  102.  
  103. bool operator!=(const ComparableObject &comparableObject, ValueType value)
  104.   {
  105.   return comparableObject.IsNotEqualTo(value);
  106.   }
  107.  
  108. The protected virtual functions are implemented in terms of the equal to
  109. and less than operations:
  110.  
  111. bool ComparableObject::IsNotEqualTo(ValueType value)
  112.   {
  113.   return !IsEqualTo(value);
  114.   }
  115.  
  116. Derived classes need only provide implementations for IsEqualTo and IsLessThan:
  117.  
  118. class Number : public virtual ComparableObject<const Number &>,
  119.                public virtual ComparableObject<double>
  120.   {
  121.   public:
  122.  
  123.   protected:
  124.     virtual bool IsEqualTo(const Number &value);
  125.     virtual bool IsLessThan(const Number &value);
  126.     virtual bool IsEqualTo(double value);
  127.     virtual bool IsLessThan(double value);
  128.  
  129.   private:
  130.   };
  131.  
  132. The Number class now supports all comparison operations by defining them
  133. in terms of two primitive operations per value type.  This solution is
  134. superior to STL's function templates for at least two reasons.  First, all
  135. operations are overridable by derived classes.  Second, there are fewer
  136. template instantiations than in STL's technique.
  137.  
  138.  
  139. Roger
  140.  
  141. ---
  142.  
  143. Roger L. Cauvin
  144. rcauvin@natinst.com
  145. Software Engineer
  146. National Instruments
  147.  
  148.       [ Articles to moderate: mailto:c++-submit@netlab.cs.rpi.edu ]
  149.       [  Read the C++ FAQ: http://www.connobj.com/cpp/cppfaq.htm  ]
  150.       [  Moderation policy: http://www.connobj.com/cpp/guide.htm  ]
  151.       [      Comments? mailto:c++-request@netlab.cs.rpi.edu       ]
  152.